Technote 1131

CONTENTS

Overview

What is Desktop Printing?

Checking Your Environment

Creating Desktop Printers for Apple Printers

StyleWriters

LaserWriters

LaserWriter 8.4.3 and before (PAP only)

LaserWriter 8.5.1 and above (PAP, LPR, IR, Hold, Translator, Custom)

Summary

Downloadables

This Technote documents the method that Apple uses to create desktop printers on the fly, without having the user go through Chooser.

Note: Apple does not recommend that your application do this behind the user's back; however, to prevent hacks and future incompatibilities we are documenting our "supported" method.

We also recommend that if you do create a DTP for your user, you switch the DTP back to your user's original selection so as not to interfere with their printing selection for other applications.

// ------------------------------------------------------
// checking for Desktop Printer Extension
// ------------------------------------------------------
enum { kGestaltPFEFeatures = 'dtpf' };    
Boolean HasDesktopExtension()
{
 OSErr err;
 Boolean hasIt = false;
 long gestaltResponse = NULL;
 
 err = Gestalt(kGestaltPFEFeatures, &gestaltResponse);
 if(err == noErr)
  hasIt = true;
 return hasIt;
}

// ------------------------------------------------------
// checking for Finder Scripting
// ------------------------------------------------------
Boolean HasFinderScripting()
{
 long gestaltResponse = NULL;
 return ( (Gestalt(gestaltFinderAttr, &gestaltResponse ) == noErr)  
  && ((response & (1L << gestaltOSLCompliantFinder)) != 0) );
}

// --------------------------------------------------------------
// Find the printer driver in the system extensions folder w/ the 
// specified minimum version, type and creator
// Note: This routine does not return an error code. If any error 
// should happen, it'll be thrown to the caller w/ C++ exception 
// handling. 
// The caller should be prepared to handle errors including eofErr 
// which indicates that the printer driver is not found.
// Parameters:
// inMinVersion- specify printer driver's minimum version
// inFileType - specify printer driver's file type
// inCreator - specify printer driver's creator
// outPrinterDrvrFsSpec - return the printer driver's FSSpec if 
// found
// --------------------------------------------------------------
void FindPrinterDriver(unsigned short inMinVersion, OSType inFileType, OSType inCreator
void FSSpec& outPrinterDrvrFsSpec )
{
OSErr err;
const long kSearchBufSize = 16 * 1024;
short savedResFile = CurResFile();
short startupVRefNum;
long extDirID; // of extensions folder
CInfoPBRec targetPb;
CInfoPBRec maskPb;
CSParam catSearchPb;
FSSpec foundFsSpec;
StPointerBlock searchBuf(kSearchBufSize); // buffer for PBCatSearch
Boolean foundOne = false;

 err = FindFolder(-1, kExtensionFolderType, FALSE, &startupVRefNum, &extDirID);
 ThrowIfOSErr_(err);

 targetPb.hFileInfo.ioFlFndrInfo.fdType = inFileType; 
 targetPb.hFileInfo.ioFlFndrInfo.fdCreator = inCreator;
 targetPb.hFileInfo.ioNamePtr = 0;
 targetPb.hFileInfo.ioFlAttrib = 0x00; // search for file only
 targetPb.hFileInfo.ioFlParID = extDirID; // in extensions folder only

 maskPb.hFileInfo.ioFlFndrInfo.fdType = 0xFFFFFFFF;
 maskPb.hFileInfo.ioFlFndrInfo.fdCreator = 0xFFFFFFFF;
 maskPb.hFileInfo.ioFlFndrInfo.fdFlags = 0;
 maskPb.hFileInfo.ioFlFndrInfo.fdLocation.h = 0;
 maskPb.hFileInfo.ioFlFndrInfo.fdLocation.v = 0;
 maskPb.hFileInfo.ioFlFndrInfo.fdFldr = 0;
 maskPb.hFileInfo.ioNamePtr = 0; 
 maskPb.hFileInfo.ioFlAttrib = 0x10;  // directory bit
 maskPb.hFileInfo.ioFlParID = extDirID; // in extensions folder only

 Try_{
  catSearchPb.ioCatPosition.initialize = 0;
  while(!foundOne ){
   catSearchPb.ioCompletion = 0;
   catSearchPb.ioNamePtr = 0;
   catSearchPb.ioVRefNum = startupVRefNum;
   catSearchPb.ioMatchPtr = &foundFsSpec;
   catSearchPb.ioReqMatchCount = 1;
   catSearchPb.ioSearchBits = fsSBFlAttrib + 
      fsSBFlFndrInfo + fsSBFlParID;
   catSearchPb.ioSearchInfo1 = &targetPb;
   catSearchPb.ioSearchInfo2 = &maskPb;
   catSearchPb.ioSearchTime = 0;
   catSearchPb.ioOptBuffer = (Ptr)searchBuf;
   catSearchPb.ioOptBufSize = kSearchBufSize;
   err = PBCatSearchSync(&catSearchPb);
   ThrowIfOSErr_(err);
   
    // found one w/ the specified type and creator
   LFile thePrDrFile(foundFsSpec); 
   Try_{
    thePrDrFile.OpenResourceFork(fsRdPerm);
    // version of printer driver
    StResource versRsrc('vers', 1, true, true); 
    // compare against minimum version
    if(**(unsigned short **)(Handle)versRsrc >= inMinVersion){
     // found one meeting the version requirement
     outPrinterDrvrFsSpec = foundFsSpec;
     foundOne = true; // get out of the loop
    }
    thePrDrFile.CloseResourceFork();
   }Catch_(inErr){
    thePrDrFile.CloseResourceFork();
    // don't throw
   }EndCatch_
  } // while
 }Catch_(inErr){
  // restore default resource file
  UseResFile(savedResFile);
  Throw_(inErr);
 }EndCatch_
}       

typedef struct DTPInfo{
   short    vRefNum;     // vRefNum of the DTP folder
   long  dirID;          // directory ID of the DTP folder
   Str31    DTPName;     // name of the DTP folder
   OSType   driverType;  // creator type of the print driver for this DTP
   Boolean  current;     // is this DTP currently the default printer
   Str32 printerName;    // name of the acutal printer on the net (only for LW8.4)
   Str32 zoneName;       // zone where this printer resides (only for LW8.4 DTPs)
} DTPInfo, *DTPInfoPtr, **DTPInfoHdl;

#define errDTPNotFound -1
#define kGestaltPFEInfo  'dtpx'

enum 
{
     kOldPFEGestaltStructVersion     = 0x02008000,   // version 2.0f0 (for Mac OS 8.0, 8.1 and 7.x)        
     kPFEGestaltStructVersion        = 0x03000000    // version 3.0 (for Allegro)
};

// GestaltDTPInfo
typedef struct
{
        short   vRefNum;                // vRefNum of the DTP folder
        long    dirID;                  // directory ID of the DTP folder
        Str31   dtpName;                // name of the DTP folder        
        OSType  driverType;             // creator type of the print driver for this DTP        
        Boolean current;                // is this DTP currently the default printer?        
        Str32   printerName;    // name of the acutal printer on the net (only for LaserWriter 8 dtps)        
        Str32   zoneName;               // zone where this printer resides (only for LaserWriter 8 dtps)
        
} GestaltDTPInfo, *GestaltDTPInfoPtr;

// data associated with the pfe gestalt
typedef struct
{
        long    version;                        // kPFEGestaltStructVersion        
        short   numDTPs;                        // number of the active dtps        
        Handle  theDTPList;                     // handle to a list of GestaltDTPInfo for the active dtps       
        Handle  theDTPDriverList;       // handle to a list of drivers' files specs       
        Handle  theDTPMoreInfoList;     // Apple's Internal use only.
        
} GestaltPFEInfo, **GestaltPFEInfoHdl;

// ---------------------------------------------------------------------------
// Look through the list of DTP's looking for a DTP
// that describes the printer with the network address
// 'papaH' and associated with a printer driver whose file spec is 
// *printerDrvrFsSpecP.
// papaH is ignored if it's NULL.
// printerDrvrFsSpecP is ignored if it's NULL.
// 
// If a match is found, then noErr is returned.
// If a match can not be found then an error is returned.
// If the caller wants information about the matched
// printer, then on entry, *'DTPInfoP' should be non-NULL
// and point to an allocated DTPInfo structure.
// ---------------------------------------------------------------------------
OSStatus 
nessieFindDTP(Handle papaH, FSSpec *printerDrvrFsSpecP, DTPInfo *DTPInfoP) 
{
 DTPInfoPtr found = NULL;
 GestaltPFEInfoHdl gestaltResponse;
 char papaHState;
 OSStatus err;
 
 if(papaH){
  papaHState = HGetState(papaH);
  HLock(papaH);
 }
 
 err = Gestalt(kGestaltPFEInfo, (long *)&gestaltResponse);
 if(!err && gestaltResponse != NULL){
  int numDTPs = (*gestaltResponse)->numDTPs;
  DTPInfoHdl DTPH = (*gestaltResponse)->theDTPList;
  FSSpec** driverH = (*gestaltResponse)->theDTPDriverList;
  
  err = errDTPNotFound;
  if((numDTPs > 0) && (DTPH != NULL) && (driverH != NULL)){
   DTPInfoPtr DTP;
   FSSpec *driverP;
   char DTPState = HGetState((Handle)DTPH);
   char driverListState = HGetState((Handle)driverH);
   HLock((Handle)DTPH);
   HLock((Handle)driverH);
   DTP = *DTPH;
   driverP = *driverH;
   if((DTP != NULL) && (driverP != NULL)){
    StringPtr printerStr;      // Points to printer's name
    StringPtr zoneStr;         // Will point to zone name (first we
                               // skip object type).
    int i;
    if(papaH){
     printerStr = (StringPtr)*papaH;          // Points to printer's name
     zoneStr = printerStr + *printerStr + 1;  // Will point to zone name 
                                              // (first we skip object type).
     zoneStr += *zoneStr + 1;                 // Now points to zone name.
    }
    
    for(i = 0; i < numDTPs && found == NULL; 
    ++i, ++DTP, ++driverP){
     // This DTP matches the one we want if it's        
     // created with the specified printer driver and               
     // the zone and printer names match.
     if(papaH){
      if(((printerDrvrFsSpecP == NULL) || 
       ((printerDrvrFsSpecP->vRefNum == driverP->vRefNum) && 
(printerDrvrFsSpecP->parID == driverP->parID) &&(EqualString(printerDrvrFsSpecP->name, driverP->name, false, false)))) &&
      EqualString(printerStr, DTP->printerName, false, false) && 
EqualString(zoneStr, DTP->zoneName, false, false)){
       found = DTP;  
      }
     }else{
      if((printerDrvrFsSpecP != NULL) && 
       ((printerDrvrFsSpecP->vRefNum == driverP->vRefNum) &&
       (printerDrvrFsSpecP->parID == driverP->parID) && 
      (EqualString(printerDrvrFsSpecP->name, driverP->name, false, false)))){
       found = DTP;  
      }
     }
    }
    if(found != NULL){
     if(DTPInfoP) *DTPInfoP = *found;
    }
   }
   HSetState((Handle)driverH, driverListState);
   HSetState((Handle)DTPH, DTPState);
  }
 }
 
 if(papaH)
  HSetState(papaH, papaHState);
 
 return found == NULL ? errDTPNotFound : noErr;
}


// ---------------------------------------------------------------------------
// Given a FSSpec of a printer driver, this routine can decide if its DTP exists
// ---------------------------------------------------------------------------
Boolean HasDTP(DTPInfo *DTPInfoP, FSSpec *prDriverFsSpecP) 
{
 OSStatus err;

 err = nessieFindDTP(NULL, prDriverFsSpecP, DTPInfoP); 
 return(!err);
}

#define kWaitForDTPTime   (60 * 20)
// ---------------------------------------------------------------------------
// CreateDTP
// This routine demonstrates how to create a DTP for StyleWriter1200
// ---------------------------------------------------------------------------
void
CreateDTP()
{
 OSErr err;
 short savedResFile = CurResFile(); 
 FSSpec printerDriverFSSpec;
 AliasHandle theAlias;
 EventRecord eventRec;
 unsigned long endTime = TickCount() + kWaitForDTPTime;
 DTPInfo DTPInfo;

                    // checking the environment
                    // make sure we have Desktop Printer Extension
                    // and Finder Scripting Extension
 if(HasDesktopExtension() && HasFinderScripting()){
  Try_{
   FindPrinterDriver(0x0120, 
    'PRER', 'dblo', FSSpec& // StyleWriter1200
    printerDriverFSSpec);
   
   /* if you are creating DTP for LaserWriter type of 
      printer driver, you'll need to write some more 
      code here. 
      Let's call LaserWriterExtra();
   */

   UseResFile(0);   // system file
                    // make alias for printer driver
   err = NewAlias(nil, &printerDriverFSSpec, &theAlias);
   ThrowIfOSErr_(err);
                    // set current printer to our printer driver
   SetResource('alis', -8192, theAlias);
   SetStrResource('STR ', -8192, printerDriverFSSpec.name);
   DisposeHandle(theAlias);
   
                    // we should notify Desktop Printer Extension
                    // that we have changed the default printer
   err = nessieCreateDTP();
                    // verify that the DTP is created
   do{ 
                    // give Desktop Printer Extension a chance
                    // to handle the request to create DTP
    EventAvail(everyEvent, &eventRec);
    newDTPMade = HasDTP(&DTPInfo,  &printerDriverFSSpec); 
   }while((TickCount() < endTime) && (newDTPMade == FALSE));
                    // until either the DTP is made or time-out
  }Catch_(inErr){
                    // handle error…
  }EndCatch_  
 }
 UseResFile(savedResFile);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for pre-8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inZone,   
   ConstStr32Param inPrinterName){
 OSErr err;
 char papaState;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();
 
 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

    papaState = HGetState(papaH);
 HLock(papaH);
 // change PAPA resource content
 NBPSetEntity(*papaH, (ConstStr32Param)StringPtr(inPrinterName), 
   (ConstStr32Param)("\pLaserWriter"),
   (ConstStr32Param)inZone);

 HSetState(papaH, papaState );
 ChangedResource(papaH); // mark dirty
 WriteResource(papaH);   // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

#define kNoCollection -2
OSErr psStorePrinterName(Collection prInfo, Handle papa); 
/* store a normalized EntityName into collection prInfo */


/* 
 add a hint to a DTP's collection
 The memory block pointed by 'bufP' of length 'size' is added as a hint of 'tag' and 
   'id' to the DTP 
whose PAPA is specified by 'papaH'. 
 Note: the resource fork of LaserWriter must be open before this routine    is called.
*/
OSErr addHint(Handle papaH, CollectionTag tag, long id, long size, void *bufP){

 Handle lwPrefFileNameH;
 char savedHandleState;
 Collection DTPCollection;

 // we need the name of LW's pref. file
 lwPrefFileNameH= GetString(-8185 );
 // don't forget to handle error
 savedHandleState = HGetState(inHandle);
 HLock(lwPrefFileNameH);
 // use routine in SettingsLib to get the collection and add item
 DTPCollection= psGetPrefsPrinterInfo((StringPtr)(*lwPrefFileNameH), papaH); 
 if(DTPCollection== nil) 
  // don't forget to handle error
  err = kNoCollection;
 
 err = psStorePrinterName(DTPCollection, papaH);   
 // handle error 
 err = AddCollectionItem(DTPCollection, tag, id, size, bufP);
 // handle error 
 err = psUpdatePrefsPrinterInfo(*lwPrefFileNameH, papaH, DTPCollection); 
 DisposeCollection(DTPCollection);
 // clean up
 HSetState(lwPrefFileNameH, savedHandleState );
 ReleaseResource(lwPrefFileNameH);
 return (err);
}

OSStatus psGetPPDInfo(FSSpecPtr driver, Handle papaH, 
long structVersion, PrinterPPDInfo *ppdInfo);
/* Return the PPD information for the printer specified by 'papaH' for the printer
 specified by 'driver'. The PPD information is returned in *'ppdInfo'. 
 The caller must pass in the version of the PrinterPPDInfo structure being used, 
 this should be the constant 'kPPDInfoStructVersion'. If the caller's structure is 
 not compatable with the routine, then the routine returns ' errWrongStructVersion'.
*/

OSStatus psSetPPDInfo(FSSpecPtr driver, Handle papaH, 
long structVersion, PrinterPPDInfo *ppdInfo);
/* Set the ppd file and the parsed ppd file for the printer driver specified
 by 'driver' and the printer specified by 'papaH'. The FSSpec's of the PPD file
 and the parsed PPD file are passed in the structure pointed to by' ppdInfo' along
 with a flag indicating whether the generic PPD should be used. If the generic PPD
 flag is set, then only the parsed PPD FSSpec need be valid. 'structVersion' indicates
 the version of the PrinterPPDInfo structure the caller is using. The caller should pass
 in the constant 
*/

OSErr ppdGetParseFolder(FSSpecPtr parseFolder);
/* Fill in the FSSpec pointed to by 'parseFolder' with
 the 'vRefNum' and 'parID' of the parsed PPD folder.
 The client can place a parsed PPD file name into the
 FSSpec's 'name' field and then use the File Manager's
 Open call's to open a parsed PPD. Note that *parseFolder'
 is not the FSSpec of the parsed PPD folder.
*/

OSErr ppdParseFile (const FSSpec *ppdFileSpec, short compiledRef, short compiledResFRef, 
  PPDParseErr *errInfoP);
/* Parse a PPD file, and all its includes.
 FSSpecPtr will be closed upon exit.
 The PPD is parsed into the open file with the file reference 'compiledRef'.
 If compiledResFRef is not -1, the resource fork of the ppd file is copied into it.
 If 'errInfoP' is not NULL, then any error information is returned in
 *'errInfoP'. 
*/

enum PPDPresetSource {
 kPPDSourceUnknown = -1,
 kPPDSourceRSRC = 0,
 kPPDSourceGeneric = 1,
 kPPDSourceCustom = 2
};

typedef enum{
 kTriFalse = 0,
 kTriTrue,
 kTriUnknown
} TriState;

struct CustPPDInfo {
 Boolean   usePPD;
 FSSpec   fileSpec;
};
typedef struct CustPPDInfo CustPPDInfo, **CustPPDHandle;

typedef struct {
 short presetSource;  /* enum PPDPresetSource */
 TriState isSetup;
 CustPPDInfo customPPD;
} WhatPPD;

typedef struct PrinterPPDInfo{
 long  structVersion;     // Identifies the version of the rest of this structure.
 Boolean  useGenericPPD;  // True if the generic PPD should be used.
 FSSpec  ppdFile;         // FSSpec of the current PPD file.
 FSSpec  parsedPPDFile;   // FSSpec of the parsed PPD file for the printer.
}PrinterPPDInfo;


/*
This routine parse a ppd file specified ppdFsSpec
and add the corresponding hints to a DTP specified 
by papaH
*/
OSErr SetPPD(FSSpec* ppdFsSpecP, Handle papaH, FSSpec* laserWriterFsSpecP)
{
 OSErr err = noErr;
 FSSpec parsedPPD;
 WhatPPD whatPPD;
 short savedResFile = ::CurResFile();
 Boolean isGeneric = false;
 short dataForkRefNum, resourceForkRefNum;
 PrinterPPDInfo ppdInfo;

 // default
 whatPPD.presetSource = kPPDSourceCustom;
 whatPPD.isSetup = kTriTrue;
 whatPPD.customPPD.usePPD = TRUE;
 whatPPD.customPPD.fileSpec = *ppdFsSpecP;

 // prepare parsed PPD FSSpec
 err = ppdGetParseFolder(&parsedPPD); 
 ThrowIfOSErr_(err);
 CopyPStr(ppdFsSpecP->name, parsedPPD.name, sizeof(parsedPPD.name));

 // create parsed file and open its resource/data fork
 FSpCreateResFile(&parsedPPD, 'vgrd', 'Pref', smSystemScript);
 err = SpOpenDF(&parsedPPD, fsRdWrPerm, &dataForkRefNum);
 resourceForkRefNum = ::FSpOpenResFile(&parsedPPD, fsRdWrPerm);
 // parse ppd
 err = ppdParseFile (ppdFsSpecP, dataForkRefNum, resourceForkRefNum, NULL);
 // close resource/data fork 
 CloseResFile(resourceForkRefNum);
 err = FSClose(dataForkRefNum);
 UseResFile(savedResFile);

 // associate the ppd with the printer
 err = addHint(papaH, 'pppd', 1, sizeof(parsedPPD), &parsedPPD);
 err = addHint(papaH, 'ppd ', 1, sizeof(whatPPD), &whatPPD);
 // set default hints
 err = psGetPPDInfo(laserWriterFsSpecP, papaH, 2, &ppdInfo);
 if(!err) err = psSetPPDInfo(laserWriterFsSpecP, papaH, 2, &ppdInfo);

 return (err);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inZone,   
   ConstStr32Param inPrinterName){
 OSErr err;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();
 SSpec ppdFsSpec;

 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

 // change PAPA resource content
 // See SettingsLib Spec  for psSetPapPapa
 err = psSetPapPapa(papaH, inPrinterName, 
  (const Byte *)("\pLaserWriter"), inZone, 0);
 // handle error…

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH);   // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// where inTcpAddr is the network address of the lpr printer.
// This address can be in either name or dot format, i.e either "\plaser.rbi.com"
// or "\p204.188.109.155". 
// inQNameis the name of the print queue associated with
// a spooler at inTcpAddr. If inQName is NULL then the default queue for the
// printer/spooler is used.
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inTcpAddr,   
   ConstStr32Param inPrinterName,
   ConstStr32Param inQName){
 OSErr err;
 short refNum;
 Handle papaH;
 Handle ipAddrQueueH;
 short savedResFile = CurResFile();
 
 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

 // change PAPA resource content
 // See SettingsLib Spec  for psSetLprPapa
 err = psSetLprPapa(papaH, inPrinterName, (const Byte *)("\p=LPR"), 
  (const Byte *)(*inTcpAddr), (const Byte *)inQName); 
 // handle error…

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 // specify domain address and queue of the printer
 err = PtrToHand(inTcpAddr, &ipAddrQueueH, inTcpAddr[0] + 1);
 err = PtrAndHand(inQName, ipAddrQueueH, inQName[0] + 1);
 HLock(ipAddrQueueH);
 err = addHint(papaH, 'LpIa', 1, GetHandleSize(ipAddrQueueH), *ipAddrQueueH);
 HUnlock(ipAddrQueueH);
 DisposHandle(ipAddrQueueH);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inPrinterName){
 OSErr err;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();
 
 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

 // change PAPA resource content
 // See SettingsLib Spec  for psSetInfraredPapa
 err = psSetInfraredPapa(papaH, inPrinterName, ("\p=Ird"));
 // handle error…

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

// 
---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inPrinterName){
 OSErr err;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();
 
 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

 // change PAPA resource content
 // See SettingsLib Spec  for psSetHoldPapa
 err = psSetHoldPapa(papaH, inPrinterName, ("\p=Hld"));
 // handle error…

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

 struct SaveAsFilePrefs{
 Boolean  saveToFile; // true for printing to file
 Boolean  restricted; // true for printing to file
};

// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inPrinterName,
   FSSpec* destinationFolderP){
 OSErr err;
 short refNum;
 Handle papaH;
 SaveAsFilePrefs saveToFilePref;
 AliasHandle printToDiskAliasH;
 short savedResFile = CurResFile();
 
 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

 // change PAPA resource content
 // See SettingsLib Spec  for psSetFilePapa
 err = psSetFilePapa(papaH, inPrinterName, "\p=Fil");
 // handle error…

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 // print to disk hint
 saveToFilePref.saveToFile = TRUE;
 saveToFilePref.restricted = TRUE;
 prefCollection.AddItem('Svap', 1, sizeof(saveToFilePref), &saveToFilePref);

 // set print to disk default folder
 err = NewAliasMinimal(destinationFolderP, &printToDiskAliasH);
 HLock((Handle)printToDiskAliasH);
 err = addHint(papaH, 'Pdka', 1, 
  GetHandleSize((Handle)printToDiskAliasH), *printToDiskAliasH);
 HUnlock((Handle)printToDiskAliasH);
 DisposeHandle((Handle)printToDiskAliasH);
 
 // change PAPA resource content
 ChangedResource(papaH); // mark dirty
 WriteResource(papaH); // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}

      
 typedef struct{           // see "Custom DTPs".
 long flag;                // kIncludeAllFontsBut or kIncludeAllFontsBut  
 unsigned char name[1];    // font name
 }FOntHint;

struct CustomAppDesc{
 OSType appSignature;      // target application's signature
 Str255 docType;           // appears in the list of doc. types
                           // when "New" menu is selected
 Str255 helpText;          // lin43, appears when the type of 
                           // this DTP is selected
 Str255 usage;             // appears as the DTP usage in the window
 Str255 appFileName;       // default application file name, used in 
                           // error message and etc.
 short numOfHintsFollow;   // 1 based
 HintRsrcSpec hintRsrc[1]; // variable length
};
typedef struct CustomAppDesc CustomAppDesc;
typedef struct CustomAppDesc* CustomAppDescPtr;
typedef struct CustomAppDesc** CustomAppDescHdl;


/*
 This routine adds custom DTP hints to the DTP specified papaH.
 The FSSpec of the post-processing application is pointed to by ppApp.
 Note how AliasHandle for the post-processing application is
 generated and added as a 'TGap' hint.
*/
OSErr addCustomDtpParameters(FSSpec* ppApp, Handle papaH){
 OSErr err; 
 long psLevel = 1;       // postscript level 1
 Byte binaryOK = 0;      // false
 char job = 0;           // psJobPostScript
 FOntHint fontHint;
 AliasHandle targetAppAliasH;
 CustomAppDesc customAppDesc;

 // postscript level 1
 err = addHint(papaH, 'pslv', 1, siezof(psLevel ), &psLevel ){
 // no Binary 
 err = addHint(papaH, 'bnok', 1, siezof(binaryOK ), &binaryOK ){
 // PostScript job
 err = addHint(papaH, 'jobt', 1, siezof(job ), &job ){
 // includeAllFonts
 fontHint.flag = 1;
 fontHint.name [0] = 0;
  err = addHint(papaH, 'font', 1, siezof(fontHint), &fontHint){

 // save target application's location
 err = ::NewAliasMinimal(ppApp, &targetAppAliasH);
 // handle error
 ::HLock((Handle)targetAppAliasH);
 err = addHint('TGap', 1, 
  GetHandleSize((Handle)targetAppAliasH),    *targetAppAliasH);
 ::HUnlock((Handle)targetAppAliasH);
 ::DisposeHandle((Handle)targetAppAliasH);

 // if you want Apple's Desktop Printer Utility to recognize and being able to 
 // open your DTP, you must add the 'CsDs' hint
 
 // fill out fields in customAppDesc for post-processing application
 customAppDesc.appSignature = 'xxxx'; // of post-processing application
 /* and all other fields…
 */
 // save custom app's description
 err = addHint(('CsDs', 1, sizeof(customAppDesc), &customAppDesc);
 return err;
}


// ---------------------------------------------------------------------------
// LaserWriterExtra for 8.5.1 LW
// point current printer to target
// ---------------------------------------------------------------------------
LaserWriterExtra(FSSpec *printerDrvrFsSpecP, 
   ConstStr32Param inPrinterName){
 OSErr err;
 FSSpec postProcessAppFsSpec;
 short refNum;
 Handle papaH;
 short savedResFile = CurResFile();
 
 // open printer driver resource fork
 err = FSpOpenResFile(printerDrvrFsSpecP, fsWrPerm, &refNum);
 // handle error…
 
 // get PAPA resource from printer driver
 papaH= Get1Resource('PAPA' , -8192);
 // handle error…

 // See SettingsLib Spec  for psSetCustomPapa
 err = psSetCustomPapa(papaH, inPrinterName, "\p=Cst");
 // handle error…

 // specify PPD file w/ ppdFsSpec
 err = FSMakeFSSpec(vRefNum,dirID,fileName,&ppdFsSpec);
 err = SetPPD(&ppdFsSpec, papaH, printerDrvrFsSpecP);

 // specify post-processing app. and other parameters
 err = FSMakeFSSpec(vRefNum, dirID, "\pYourPostProcessAppName",
  &postProcessAppFsSpec);
 err = addCustomDtpParameters(&postProcessAppFsSpec, papaH);

 // change PAPA resource content
 ChangedResource(papaH); // mark dirty
 WriteResource(papaH);   // update resource
 err = FSClose(refNum);
 UseResFile(savedResFile);
}